package de.fhhannover.inform.hnefatafl.strategy;

import java.util.ArrayList;
import java.util.Random;

import de.fhhannover.inform.hnefatafl.vorgaben.BoardContent;
import de.fhhannover.inform.hnefatafl.vorgaben.Cell;
import de.fhhannover.inform.hnefatafl.vorgaben.Move;
import de.fhhannover.inform.hnefatafl.vorgaben.MoveStrategy;




public class G15_Strategy implements MoveStrategy{
	
	Board 			gamingBoard;
	MoveChecker		moveChecker;
	Field 			board[][];
	Move 			move;

	public G15_Strategy(){
		gamingBoard = new Board();
		moveChecker = new MoveChecker();
		gamingBoard.fillBoard();
		board 		= gamingBoard.getBoard();
	}

	@Override
	public Move calculateDefenderMove(Move lastMove, int thinkTimeInSekonds) {
		gamingBoard.makeMove(lastMove);
		for(int i = 0; i < 10000; i++){}
		ArrayList<Move> possibleMoves = moveChecker.getDefenderMoves(gamingBoard.getBoard());
		move = getUltimateMove(possibleMoves);
		gamingBoard.makeMove(move);
		return move;
	}

	@Override
	public Move calculateAttackerMove(Move lastMove, int thinkTimeInSekonds) {
		if(lastMove != null){
			gamingBoard.makeMove(lastMove);
			for(int i = 0; i < 10000; i++){}
		} 
		ArrayList<Move> possibleMoves = moveChecker.getAttackerMoves(gamingBoard.getBoard());
		move = getUltimateMove(possibleMoves);
		gamingBoard.makeMove(move);
		return move;
	}
	
	
	@Override
	public int getGroupNr() {
		return 15;
	}

	@Override
	public String getStrategyName() {
		return "Random-G15-Strategy";
	}
	
	private Move getUltimateMove(ArrayList<Move> moves){
		
		Random 	random = new Random();
		Zug 	ultimateMove;
		int 	oberGrenze = moves.size()-1;
		
		ultimateMove = (Zug) moves.get(random.nextInt(oberGrenze));
		
		return (Move)ultimateMove;
	}
	
	class Field implements Cell{
		int 			col;
		int 			row;
		boolean 		hasEnemyWest,
						hasEnemyEast,
						hasEnemyNorth,
						hasEnemySouth;
		BoardContent 	content;
		
		public Field(int col, int row){
			this.col = col;
			this.row = row;
		}
		
		public Field(int col, int row, BoardContent content){
			this.col 		= col;
			this.row 		= row;
			this.content	= content;
			hasEnemyWest 	= false;
			hasEnemyEast 	= false;
			hasEnemyNorth 	= false;
			hasEnemySouth 	= false;
		}

		@Override
		public int getCol() {
			return col;
		}

		@Override
		public int getRow() {
			return row;
		}

		@Override
		public BoardContent getContent() {
			return content;
		}
		
		void setContent(BoardContent content){
			this.content = content;
		}
		
		void setContentEmpty(){
			this.content = BoardContent.EMPTY;
		}
		
		@Override
		public String toString(){
			return String.format("["+col+", "+row+"]");
		}
		
		public boolean getWest(){
			return hasEnemyWest;
		}
		
		public void setWest(){
			this.hasEnemyWest = true;
		}
		
		public boolean getEast(){
			return hasEnemyEast;
		}
		
		public void setEast(){
			this.hasEnemyEast = true;
		}
		
		public boolean getNorth(){
			return hasEnemyNorth;
		}
		
		public void setNorth(){
			this.hasEnemyNorth = true;
		}
		
		public boolean getSouth(){
			return hasEnemyWest;
		}
		
		public void setSouth(){
			this.hasEnemyWest = true;
		}
		
		public void setDefault(){
			hasEnemyEast = false;
			hasEnemyWest = false;
			hasEnemySouth = false;
			hasEnemyNorth = false;
		}
		

	}

	class Board{
		
		int 				thinkingTime,
							roundCounter;
		String 				attackerName,
		 					defenderName;
		boolean 			isAttackerHuman,
		 					isDefenderHuman,
		 					isAttackersTurn,
		 					isGameRunning,
		 					attackerWon,
		 					defenderWon;
		Field 				board[][];
		Cell				temp,
		 					source, 
		 					destination;
		public MoveChecker	moveChecker;
		
		
		public Board(){
			board = new Field[15][15];
			moveChecker = new MoveChecker();
		}
		
		
		
		//hier wird das Spielfelder gefuellt 
		void fillBoard(){
			for(int i = 0; i < 15; i++){
				//Attacker
				for(int j = 0; j < 15; j++){
					if((i == 1 && j == 5)||(i == 1 && j == 6)||(i == 1 && j == 7)||(i == 1 && j == 8)||(i == 1 && j == 9)||
					   (i == 2 && j == 7)||
					   (i == 5 && j == 1)||(i == 5 && j == 13)||
					   (i == 6 && j == 1)||(i == 6 && j == 13)||
					   (i == 7 && j == 1)||(i == 7 && j == 2)||(i == 7 && j == 12)||(i == 7 && j == 13)||
					   (i == 8 && j == 1)||(i == 8 && j == 13)||
					   (i == 9 && j == 1)||(i == 9 && j == 13)||
					   (i == 12 && j == 7)||
					   (i == 13 && j == 5)||(i == 13 && j == 6)||(i == 13 && j == 7)||(i == 13 && j == 8)||(i == 13 && j == 9)){
					this.board[i][j] = new Field(j-1,i-1,BoardContent.ATTACKER);
					//Deffender
					}else if((i == 5 && j == 7)||
							 (i == 6 && j == 6)||(i == 6 && j == 7)||(i == 6 && j == 8)||
							 (i == 7 && j == 5)||(i == 7 && j == 6)||(i == 7 && j == 8)||(i == 7 && j == 9)||
							 (i == 8 && j == 6)||(i == 8 && j == 7)||(i == 8 && j == 8)||
							                                           (i == 9 && j == 7)){
						this.board[i][j] = new Field(j-1,i-1,BoardContent.DEFENDER);
					//King
					}else if((i == 7 && j == 7)){
						this.board[i][j] = new Field(j-1,i-1,BoardContent.KING);
					//Empty
					}else if(  (i == 1 && j == 1) ||(i == 1 && j == 2) ||(i == 1 && j == 3)  ||(i == 1 && j == 4)||
							   (i == 1 && j == 10) ||(i == 1 && j == 11)||(i == 1 && j == 12) ||(i == 1 && j == 13)||
							   (i == 2 && j == 1) ||(i == 2 && j == 2) ||(i == 2 && j == 3)  ||(i == 2 && j == 4)||(i == 2 && j == 5)||(i == 2 && j == 6)||
							   (i == 2 && j == 8) ||(i == 2 && j == 9) ||(i == 2 && j == 10)  ||(i == 2 && j == 11)||(i == 2 && j == 12)||(i == 2 && j == 13)||
							   (i == 3 && j == 1) ||(i == 3 && j == 2) ||(i == 3 && j == 3)  ||(i == 3 && j == 4)||(i == 3 && j == 5)||(i == 3 && j == 6)||
							   (i == 3 && j == 7) ||(i == 3 && j == 8) ||(i == 3 && j == 9)  ||(i == 3 && j == 10)||(i == 3 && j == 11)||(i == 3 && j == 12)||(i == 3 && j == 13)||
							   (i == 4 && j == 1) ||(i == 4 && j == 2) ||(i == 4 && j == 3)  ||(i == 4 && j == 4)||(i == 4 && j == 5)||(i == 4 && j == 6)||
							   (i == 4 && j == 7) ||(i == 4 && j == 8) ||(i == 4 && j == 9)  ||(i == 4 && j == 10)||(i == 4 && j == 11)||(i == 4 && j == 12)||(i == 4 && j == 13)||
							   (i == 5 && j == 2) ||(i == 5 && j == 3) ||(i == 5 && j == 4)  ||(i == 5 && j == 5)||(i == 5 && j == 6)||
							   (i == 5 && j == 8) ||(i == 5 && j == 9) ||(i == 5 && j == 10)  ||(i == 5 && j == 11)||(i == 5 && j == 12)||
							   (i == 6 && j == 2) ||(i == 6 && j == 3) ||(i == 6 && j == 4)  ||(i == 6 && j == 5)||
							   (i == 6 && j == 9) ||(i == 6 && j == 10) ||(i == 6 && j == 11) ||(i == 6 && j == 12)||
							   (i == 7 && j == 3) ||(i == 7 && j == 4) ||(i == 7 && j == 10)  ||(i == 7 && j == 11)||
							   (i == 8 && j == 2) ||(i == 8 && j == 3) ||(i == 8 && j == 4)  ||(i == 8 && j == 5)||
							   (i == 8 && j == 9) ||(i == 8 && j == 10) ||(i == 8 && j == 11) ||(i == 8 && j == 12)||
							   (i == 9 && j == 2) ||(i == 9 && j == 3) ||(i == 9 && j == 4)  ||(i == 9 && j == 5)||(i == 9 && j == 6)||
							   (i == 9 && j == 8) ||(i == 9 && j == 9) ||(i == 9 && j == 10)  ||(i == 9 && j == 11)||(i == 9 && j == 12)||
							   (i == 10 && j == 1) ||(i == 10 && j == 2) ||(i == 10 && j == 3)  ||(i == 10 && j == 4)||(i == 10 && j == 5)||(i == 10 && j == 6)||
							   (i == 10 && j == 7) ||(i == 10 && j == 8) ||(i == 10 && j == 9)  ||(i == 10 && j == 10)||(i == 10 && j == 11)||(i == 10 && j == 12)||(i == 10 && j == 13)||
							   (i == 11 && j == 1)||(i == 11 && j == 2)||(i == 11 && j == 3) ||(i == 11 && j == 4)||(i == 11 && j == 5)||(i == 11 && j == 6)||
							   (i == 11 && j == 7)||(i == 11 && j == 8)||(i == 11 && j == 9) ||(i == 11 && j == 10)||(i == 11 && j == 11)||(i == 11 && j == 12)||(i == 11 && j == 13)||
							   (i == 12 && j == 1)||(i == 12 && j == 2)||(i == 12 && j == 3) ||(i == 12 && j == 4)||(i == 12 && j == 5)||(i == 12 && j == 6)||
							   (i == 12 && j == 8)||(i == 12 && j == 9)||(i == 12 && j == 10) ||(i == 12 && j == 11)||(i == 12 && j == 12)||(i == 12 && j == 13)||
							   (i == 13 && j == 1)||(i == 13 && j == 2)||(i == 13 && j == 3) ||(i == 13 && j == 4)||
							   (i == 13 && j == 10)||(i == 13 && j == 11)||(i == 13&& j == 12)||(i == 13 && j == 13)){
						this.board[i][j] = new Field(j-1,i-1,BoardContent.EMPTY);
					//Invalid
					}else if(i == 0 && j == 0 || i == 0 && j == 1 || i == 0 && j == 2 || i == 0 && j == 3 || i == 0 && j == 4 || i == 0 && j == 5||
							 i == 0 && j == 6 || i == 0 && j == 7 || i == 0 && j == 8 || i == 0 && j == 9 || i == 0 && j == 9 || i == 0 && j == 10||
							 i == 0 && j == 11 || i == 0 && j == 12 || i == 0 && j == 13 || i == 0 && j == 14||
							 i == 1 && j == 0 || i == 1 && j == 14||
							 i == 2 && j == 0 || i == 2 && j == 14||
							 i == 3 && j == 0 || i == 3 && j == 14||
							 i == 4 && j == 0 || i == 4 && j == 14||
							 i == 5 && j == 0 || i == 5 && j == 14||
							 i == 6 && j == 0 || i == 6 && j == 14||
							 i == 7 && j == 0 || i == 7 && j == 14||
							 i == 8 && j == 0 || i == 8 && j == 14||
							 i == 9 && j == 0 || i == 9 && j == 14||
							 i == 10 && j == 0 || i == 10 && j == 14||
							 i == 11 && j == 0 || i == 11 && j == 14||
							 i == 12 && j == 0 || i == 12 && j == 14||
							 i == 13 && j == 0 || i == 13 && j == 14||
							 i == 14 && j == 0 || i == 14 && j == 1 || i == 14 && j == 2 || i == 14 && j == 3 || i == 14 && j == 4 || i == 14 && j == 5||
							 i == 14 && j == 6 || i == 14 && j == 7 || i == 14 && j == 8 || i == 14 && j == 9 || i == 14 && j == 9 || i == 14 && j == 10||
							 i == 14 && j == 11 || i == 14 && j == 12 || i == 14 && j == 13 || i == 14 && j == 14){
						this.board[i][j] = new Field(j-1,i-1,BoardContent.INVALID);
					}
				}
			}
		}
		
		//kontrolliert ueber MoveChecker ob der zug ordnungsgemaess ist,
		//wenn Ja, dann wird der zug durchgefuehrt und per Observer wird
		//das GamePanel benachichtigt.
		public void makeMove(Move move){
			
		   source =  move.getFromCell();
		   destination =  move.getToCell();	
				
			  if(moveChecker.checkMove(isAttackersTurn,move,board)){
				
				temp = new Field(source.getRow()+1,source.getCol()+1,board[source.getRow()+1][source.getCol()+1].getContent());
			
				board[source.getRow()+1][source.getCol()+1].setContent(board[destination.getRow()+1][destination.getCol()+1].getContent());
				board[destination.getRow()+1][destination.getCol()+1].setContent(temp.getContent());
				
				checkNeighbor();
				roundControll();
		 }
		}
		
		private void checkNeighbor(){
			checkOut();
			checkIn();
			checkPlace();
		}

		//Wechselt den Spieler nach einem Zug
		private void roundControll(){
			if(isAttackersTurn == true){
				isAttackersTurn = false;
				roundCounter++;
			}else{
				isAttackersTurn = true;
				roundCounter++;
			}
		}
		
		//beim zug von einem Feld weg,werden die boolean werte der nachbarn entsprechen geaendert. 
		private void checkOut(){
			if(isAttackersTurn){
				//West
				if((board[source.getRow()+1][source.getCol()].getContent() == BoardContent.DEFENDER)||
				   (board[source.getRow()+1][source.getCol()].getContent() == BoardContent.KING)){
					board[source.getRow()+1][source.getCol()].hasEnemyEast = false;
				}
				//Ost
				if((board[source.getRow()+1][source.getCol()+2].getContent() == BoardContent.DEFENDER)||
				   (board[source.getRow()+1][source.getCol()+2].getContent() == BoardContent.KING)){
					board[source.getRow()+1][source.getCol()+2].hasEnemyWest = false;
				}
				//Nord
				if((board[source.getRow()][source.getCol()+1].getContent() == BoardContent.DEFENDER)||
				   (board[source.getRow()][source.getCol()+1].getContent() == BoardContent.KING)){
					board[source.getRow()][source.getCol()+1].hasEnemySouth = false;
				}
				//Sued
				if((board[source.getRow()+2][source.getCol()+1].getContent() == BoardContent.DEFENDER)||
				   (board[source.getRow()+2][source.getCol()+1].getContent() == BoardContent.DEFENDER)){
					board[source.getRow()+2][source.getCol()+1].hasEnemyNorth = false;
				}
			}
			else{
				//West
				if(board[source.getRow()+1][source.getCol()].getContent() == BoardContent.ATTACKER){
					board[source.getRow()+1][source.getCol()].hasEnemyEast = false;
				}
				//Ost
				if(board[source.getRow()+1][source.getCol()+2].getContent() == BoardContent.ATTACKER){
					board[source.getRow()+1][source.getCol()+2].hasEnemyWest = false;
				}
				//Nord
				if(board[source.getRow()][source.getCol()+1].getContent() == BoardContent.ATTACKER){
					board[source.getRow()][source.getCol()+1].hasEnemySouth = false;
				}
				//Sued
				if(board[source.getRow()+2][source.getCol()+1].getContent() == BoardContent.ATTACKER){
					board[source.getRow()+2][source.getCol()+1].hasEnemyNorth = false;
				}
			}
		}
		
		
		private void checkIn(){
			
			//versetzt den zu ziehenden Stein in ursprungszustand
			board[destination.getRow()+1][destination.getCol()+1].setDefault();
			
			//Angreifer bewegt sich auf Feld
			if(isAttackersTurn == true){
				//Westliches Feld hat Verteidiger
				if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.DEFENDER){
					board[destination.getRow()+1][destination.getCol()].hasEnemyEast = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = true;
				}
				//Westliches Feld hat Koenig
				if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.KING){
					board[destination.getRow()+1][destination.getCol()].hasEnemyEast = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = true;
				}
				//Westliches Feld ist Turm oder leerer Thron (nur Thronfelder 0,0 oder 0,12 moeglich)
				if(destination.getRow() ==  0 && destination.getCol()-1 == 0 ||
				   destination.getRow() == 12 && destination.getCol()-1 == 0 ||
				   destination.getRow() ==  6 && destination.getCol()-1 == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = true;
				}
				//---------------------------------------------------------------------------------------
				//Oestliches Feld hat Verteidiger
				if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.DEFENDER){
					board[destination.getRow()+1][destination.getCol()+2].hasEnemyWest = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyEast = true;
				}
				//Oestliches Feld hat Koenig
				if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.KING){
					board[destination.getRow()+1][destination.getCol()+2].hasEnemyWest = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyEast = true;
				}
				//Oestliches Feld ist Turm oder leerer Thron (nur Thronfelder 12,0 oder 12,12 moeglich)
				if(destination.getRow() ==  0 && destination.getCol()+1 == 12 ||
				   destination.getRow() == 12 && destination.getCol()+1 == 12 ||
				   destination.getRow() ==  6 && destination.getCol()+1 == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyEast = true;
				}
				//--------------------------------------------------------------------------------
				//Noerdliches Feld hat Verteidiger
				if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.DEFENDER){
					board[destination.getRow()][destination.getCol()+1].hasEnemySouth = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = true;
				}
				//Noerliches Feld hat Koenig
				if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.KING){
					board[destination.getRow()][destination.getCol()+1].hasEnemySouth = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = true;
				}
				//Noerdliches Feld ist Turm oder leerer Thron (nur Thronfelder 0,0 oder 12,0 moeglich)
				if(destination.getRow()-1 ==  0 && destination.getCol() == 0 ||
				   destination.getRow()-1 ==  0 && destination.getCol() == 12 ||
				   destination.getRow()-1 ==  6 && destination.getCol() == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = true;
				}
				//---------------------------------------------------------------------------------
				//Suedliches Feld hat Verteidiger
				if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.DEFENDER){
					board[destination.getRow()+2][destination.getCol()+1].hasEnemyNorth = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemySouth = true;
					}
				//Suedliches Feld hat Koenig
				if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.KING){
					board[destination.getRow()+2][destination.getCol()+1].hasEnemyNorth = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemySouth = true;
					}
				//Suedliches Feld ist Turm oder leerer Thron (nur Thronfelder 0,12 oder 12,12 moeglich)
				if(destination.getRow()+1 == 12 && destination.getCol() == 0 ||
				   destination.getRow()+1 == 12 && destination.getCol() == 12 ||
				   destination.getRow()+1 ==  6 && destination.getCol() == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemySouth = true;
				}
			}
			//Verteidiger bewegt sich auf Feld
			if(isAttackersTurn == false && board[destination.getRow()+1][destination.getCol()+1].getContent() == BoardContent.DEFENDER){
				//Westliches Feld hat Angreifer
				if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.ATTACKER){
					board[destination.getRow()+1][destination.getCol()].hasEnemyEast = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = true;
				}
				//Westliches Feld ist Turm oder leerer Thron (nur Thronfelder 0,0 oder 0,12 moeglich)
				if(destination.getRow() ==  0 && destination.getCol()-1 == 0 ||
				   destination.getRow() == 12 && destination.getCol()-1 == 0 ||
				   destination.getRow() ==  6 && destination.getCol()-1 == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = true;
				}
				//---------------------------------------------------------------------------------------
				//Ost
				if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.ATTACKER){
					board[destination.getRow()+1][destination.getCol()+2].hasEnemyWest = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyEast = true;
				}
				//Oestliches Feld ist Turm oder leerer Thron (nur Thronfelder 12,0 oder 12,12 moeglich)
				if(destination.getRow() ==  0 && destination.getCol()+1 == 12 ||
				   destination.getRow() == 12 && destination.getCol()+1 == 12 ||
				   destination.getRow() ==  6 && destination.getCol()+1 == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyEast = true;
				}
				//--------------------------------------------------------------------------------------------
				//Nord
				if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.ATTACKER){
					board[destination.getRow()][destination.getCol()+1].hasEnemySouth = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = true;
				}
				//Noerdliches Feld ist Turm oder leerer Thron (nur Thronfelder 0,0 oder 12,0 moeglich)
				if(destination.getRow()-1 ==  0 && destination.getCol() == 0 ||
				   destination.getRow()-1 ==  0 && destination.getCol() == 12 ||
				   destination.getRow()-1 ==  6 && destination.getCol() == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = true;
				}
				//----------------------------------------------------------------------------------------------
				//Sued
				if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.ATTACKER){
					board[destination.getRow()+2][destination.getCol()+1].hasEnemyNorth = true;
					board[destination.getRow()+1][destination.getCol()+1].hasEnemySouth = true;
				}
				//Suedliches Feld ist Turm oder leerer Thron (nur Thronfelder 0,12 oder 12,12 moeglich)
				if(destination.getRow()+1 == 12 && destination.getCol() == 0 ||
				   destination.getRow()+1 == 12 && destination.getCol() == 12 ||
				   destination.getRow()+1 ==  6 && destination.getCol() == 6 && board[6+1][6+1].getContent() == BoardContent.EMPTY){
					board[destination.getRow()+1][destination.getCol()+1].hasEnemySouth = true;
				}
			}
				//--------------------------------------------------------------------------------------------
			//Koenig bewegt sich auf Feld
			if(isAttackersTurn == false && board[destination.getRow()+1][destination.getCol()+1].getContent() == BoardContent.KING){
				
				//Koenig erreicht den sicheren Turm
				if(board[destination.getRow()+1][destination.getCol()+1].getContent() == BoardContent.KING){
					if((destination.getCol() == 0 && destination.getRow() == 0)||
					   (destination.getCol() == 12 && destination.getRow() == 0)||
					   (destination.getCol() == 0 && destination.getRow() == 12)||
					   (destination.getCol() == 12 && destination.getRow() == 12)){
							defenderWon = true;
							isGameRunning = false;
					}
					
					//Westliches Feld ist Angreifer
					if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.ATTACKER){
						board[destination.getRow()+1][destination.getCol()].hasEnemyEast = true;
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = true;
					}
					//Westliches Feld ist Spielfeldrand oder Thron
					if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.INVALID ||
					  (destination.getRow() == 6 && destination.getCol()-1 == 6)){
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = true;
					}
					//Oestliches Feld ist Angreifer
					if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.ATTACKER){
						board[destination.getRow()+1][destination.getCol()+2].hasEnemyWest = true;
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyEast = true;
					}
					//Oestliches Feld ist Spielfeldrand oder Thron
					if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.INVALID ||
					  (destination.getRow() == 6 && destination.getCol()+1 == 6)){
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyEast = true;
					}
					//Noerdliches Feld ist Angreifer
					if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.ATTACKER){
						board[destination.getRow()][destination.getCol()+1].hasEnemySouth = true;
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = true;
					}
					//Noerdliches Feld ist Spielfeldrand oder Thron
					if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.INVALID ||
					  (destination.getRow()-1 == 6 && destination.getCol() == 6)){
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = true;
					}
					//Suedliches Feld ist Angreifer
					if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.ATTACKER){
						board[destination.getRow()+2][destination.getCol()+1].hasEnemyNorth = true;
						board[destination.getRow()+1][destination.getCol()+1].hasEnemySouth = true;
					}
					//suedliches Feld ist Spielfeldrand
					if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.INVALID ||
					  (destination.getRow()+1 == 6 && destination.getCol() == 6)){
						board[destination.getRow()+1][destination.getCol()+1].hasEnemySouth = true;
					}
				}
			}
		}
		
		
		//pr�ft ob benachbarte Steine geschlagen sind
		private void checkPlace(){
			//Oestlicher Stein ist Koenig
			if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.KING){
				//Koenig hat Gegner im NORDEN, SUEDEN, WESTEN und OSTEN
				if(board[destination.getRow()+1][destination.getCol()+2].hasEnemyEast == true&&
				   board[destination.getRow()+1][destination.getCol()+2].hasEnemyWest == true&&
				   board[destination.getRow()+1][destination.getCol()+2].hasEnemyNorth == true&&
				   board[destination.getRow()+1][destination.getCol()+2].hasEnemySouth == true){
					//geschlagenen Stein Empty setzen.
					board[destination.getRow()+1][destination.getCol()+2].setContentEmpty();
					attackerWon 	= true;
					isGameRunning	= false;
				}
			}
			//Oesticher Stein ist Verteidiger
			if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.DEFENDER){
				//Verteidiger hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()+1][destination.getCol()+2].hasEnemyEast == true&&
				   board[destination.getRow()+1][destination.getCol()+2].hasEnemyWest == true){
					
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()+2].setContentEmpty();
						
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()+2-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+2+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()+2].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()+2].hasEnemyNorth = false;//Sueden
				}
				//Verteidiger hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()+1][destination.getCol()+2].hasEnemyNorth == true&&
				   board[destination.getRow()+1][destination.getCol()+2].hasEnemySouth == true){
						
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()+2].setContentEmpty();
						
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()+2-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+2+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()+2].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()+2].hasEnemyNorth = false;//Sueden
					}
			}
			//Oestlicher Stein ist Angreifer
			if(board[destination.getRow()+1][destination.getCol()+2].getContent() == BoardContent.ATTACKER){
				//Angreifer hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()+1][destination.getCol()+2].hasEnemyEast == true&&
				   board[destination.getRow()+1][destination.getCol()+2].hasEnemyWest == true){
							
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()+2].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()+2-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+2+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()+2].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()+2].hasEnemyNorth = false;//Sueden
				}
				//Angreifer hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()+1][destination.getCol()+2].hasEnemyNorth == true&&
				   board[destination.getRow()+1][destination.getCol()+2].hasEnemySouth == true){
								
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()+2].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()+2-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+2+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()+2].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()+2].hasEnemyNorth = false;//Sueden
					}
			}
			//---------------------------------------------------------------------------------------------------
			//Westlicher Stein ist Koenig
			if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.KING){
				//Koenig hat Gegner im NORDEN, SUEDEN, WESTEN und OSTEN
				if(board[destination.getRow()+1][destination.getCol()].hasEnemyEast == true&&
				   board[destination.getRow()+1][destination.getCol()].hasEnemyWest == true&&
				   board[destination.getRow()+1][destination.getCol()].hasEnemyNorth == true&&
				   board[destination.getRow()+1][destination.getCol()].hasEnemySouth == true){
					//geschlagenen Stein Empty setzen.
					board[destination.getRow()+1][destination.getCol()].setContentEmpty();
					//Info das der Koenig gefangen genommen wurde und Spiel stoppen
					attackerWon 	= true;
					isGameRunning	= false;
				}
			}
			//Westlicher Stein ist Verteidiger
			if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.DEFENDER){
				//Verteidiger hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()+1][destination.getCol()].hasEnemyEast == true&&
				   board[destination.getRow()+1][destination.getCol()].hasEnemyWest == true){
					
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()].setContentEmpty();
		
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()].hasEnemyNorth = false;//Sueden
				}
				//Verteidiger hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()+1][destination.getCol()].hasEnemyNorth == true&&
				   board[destination.getRow()+1][destination.getCol()].hasEnemySouth == true){
						
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()].setContentEmpty();
						
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()].hasEnemyNorth = false;//Sueden
					}
			}
			//Westlicher Stein ist Angreifer
			if(board[destination.getRow()+1][destination.getCol()].getContent() == BoardContent.ATTACKER){
				//Angreifer hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()+1][destination.getCol()].hasEnemyEast == true&&
				   board[destination.getRow()+1][destination.getCol()].hasEnemyWest == true){
							
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()].hasEnemyNorth = false;//Sueden
				}
				//Angreifer hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()+1][destination.getCol()].hasEnemyNorth == true&&
				   board[destination.getRow()+1][destination.getCol()].hasEnemySouth == true){
								
						//geschlagenen Stein Empty setzen.
						board[destination.getRow()+1][destination.getCol()].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+1][destination.getCol()-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+1-1][destination.getCol()].hasEnemySouth = false;//Norden
						board[destination.getRow()+1+1][destination.getCol()].hasEnemyNorth = false;//Sueden
					}
			}
			//---------------------------------------------------------------------------------------------------
			//Noerdlicher Stein ist Koenig
			if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.KING){
				//Koenig hat Gegner im NORDEN, SUEDEN, WESTEN und OSTEN
				if(board[destination.getRow()][destination.getCol()+1].hasEnemyEast == true&&
				   board[destination.getRow()][destination.getCol()+1].hasEnemyWest == true&&
				   board[destination.getRow()][destination.getCol()+1].hasEnemyNorth == true&&
				   board[destination.getRow()][destination.getCol()+1].hasEnemySouth == true){
					//geschlagenen Stein Empty setzen.
					board[destination.getRow()][destination.getCol()+1].setContentEmpty();
					attackerWon 	= true;
					isGameRunning	= false;
				}
			}
			//Noerdlicher Stein ist Verteidiger
			if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.DEFENDER){
				//Verteidiger hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()][destination.getCol()+1].hasEnemyEast == true&&
				   board[destination.getRow()][destination.getCol()+1].hasEnemyWest == true){
					
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()][destination.getCol()+1].setContentEmpty();
						
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()-1][destination.getCol()+1].hasEnemySouth = false;//Norden
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = false;//Sueden
				}
				//Verteidiger hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()][destination.getCol()+1].hasEnemyNorth == true&&
				   board[destination.getRow()][destination.getCol()+1].hasEnemySouth == true){
						
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()][destination.getCol()+1].setContentEmpty();
						
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()-1][destination.getCol()+1].hasEnemySouth = false;//Norden
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = false;//Sueden
					}
			}
			//Noerdlicher Stein ist Angreifer
			if(board[destination.getRow()][destination.getCol()+1].getContent() == BoardContent.ATTACKER){
				//Angreifer hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()][destination.getCol()+1].hasEnemyEast == true&&
				   board[destination.getRow()][destination.getCol()+1].hasEnemyWest == true){
							
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()][destination.getCol()+1].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()-1][destination.getCol()+1].hasEnemySouth = false;//Norden
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = false;//Sueden
				}
				//Angreifer hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()][destination.getCol()+1].hasEnemyNorth == true&&
				   board[destination.getRow()][destination.getCol()+1].hasEnemySouth == true){
								
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()][destination.getCol()+1].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()-1][destination.getCol()+1].hasEnemySouth = false;//Norden
						board[destination.getRow()+1][destination.getCol()+1].hasEnemyNorth = false;//Sueden
					}
			}
			//---------------------------------------------------------------------------------------------------
			//Suedlicher Stein ist Koenig
			if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.KING){
				//Koenig hat Gegner im NORDEN, SUEDEN, WESTEN und OSTEN
				if(board[destination.getRow()+2][destination.getCol()+1].hasEnemyEast == true&&
				   board[destination.getRow()+2][destination.getCol()+1].hasEnemyWest == true&&
				   board[destination.getRow()+2][destination.getCol()+1].hasEnemyNorth == true&&
				   board[destination.getRow()+2][destination.getCol()+1].hasEnemySouth == true){
					//geschlagenen Stein Empty setzen.
					board[destination.getRow()+2][destination.getCol()+1].setContentEmpty();
					attackerWon 	= true;
					isGameRunning	= false;
				}
			}
			//Suedlicher Stein ist Verteidiger
			if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.DEFENDER){
				//Verteidiger hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()+2][destination.getCol()+1].hasEnemyEast == true&&
				   board[destination.getRow()+2][destination.getCol()+1].hasEnemyWest == true){
					
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()+2][destination.getCol()+1].setContentEmpty();
						
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+2][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+2][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+2-1][destination.getCol()+1].hasEnemySouth= false;//Norden
						board[destination.getRow()+2+1][destination.getCol()+1].hasEnemyNorth= false;//Sueden
				}
				//Verteidiger hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()+2][destination.getCol()+1].hasEnemyNorth == true&&
				   board[destination.getRow()+2][destination.getCol()+1].hasEnemySouth == true){
						
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()+2][destination.getCol()+1].setContentEmpty();
						
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+2][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+2][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+2-1][destination.getCol()+1].hasEnemySouth= false;//Norden
						board[destination.getRow()+2+1][destination.getCol()+1].hasEnemyNorth= false;//Sueden
					}
			}
			//Suedlicher Stein ist Angreifer
			if(board[destination.getRow()+2][destination.getCol()+1].getContent() == BoardContent.ATTACKER){
				//Angreifer hat gegner im OSTEN und WESTEN
				if(board[destination.getRow()+2][destination.getCol()+1].hasEnemyEast == true&&
				   board[destination.getRow()+2][destination.getCol()+1].hasEnemyWest == true){
							
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()+2][destination.getCol()+1].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+2][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+2][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+2-1][destination.getCol()+1].hasEnemySouth= false;//Norden
						board[destination.getRow()+2+1][destination.getCol()+1].hasEnemyNorth= false;//Sueden
				}
				//Angreifer hat gegner im NORDEN und SUEDEN
				if(board[destination.getRow()+2][destination.getCol()+1].hasEnemyNorth == true&&
				   board[destination.getRow()+2][destination.getCol()+1].hasEnemySouth == true){
								
						//geschlagenen Stein Empty setzen.
					    board[destination.getRow()+2][destination.getCol()+1].setContentEmpty();
								
						//benachbarte Steine Boolean-Werte angleichen.
						board[destination.getRow()+2][destination.getCol()+1-1].hasEnemyEast = false;//Westen
						board[destination.getRow()+2][destination.getCol()+1+1].hasEnemyWest = false;//Osten
						board[destination.getRow()+2-1][destination.getCol()+1].hasEnemySouth= false;//Norden
						board[destination.getRow()+2+1][destination.getCol()+1].hasEnemyNorth= false;//Sueden
					}
			}
		}
		
		
		
		
		public Field[][] getBoard(){
			return board;
		}
		
		public boolean getIsAttackersTurn(){
			return isAttackersTurn;
		}
		
		public boolean hasAttackerWon(){
			return attackerWon;
		}
		
		public boolean hasDefenderWon(){
			return defenderWon;
		}
		
	}//Ende

	class MoveChecker{
		
		public MoveChecker(){
		}
		
		
		boolean checkMove(boolean player,Move move,Field[][] board){
			
			if(checkPlayer(player, move, board)){
				if(checkMoveDirection(move, board)){
					if(checkMoveDistance(player, move, board)){
						if(checkTowers(player, move, board)){
							return true;
						}
						else return false;
					}
					else return false;
				}
				else return false;
			}
			else return false;
		}
		
		//--------------------------------------------------------------------
		
		//pruefen ob der Spieler auch den richtigen Spielstein setzt.
		
		boolean checkPlayer(boolean player,Move move,Field[][] board){
			
			Cell source 		=  move.getFromCell();
			
			if((board[source.getRow()+1][source.getCol()+1].getContent() == BoardContent.ATTACKER && player == true)||
			   (board[source.getRow()+1][source.getCol()+1].getContent() == BoardContent.DEFENDER && player == false)||
			   (board[source.getRow()+1][source.getCol()+1].getContent() == BoardContent.KING && player == false)){
				return true;
			}else{
				return false;
			}
		}
		
		//----------------------------------------------------------------------
		
		//pruefen ob der spielstein nach den  regeln gesetzt wird.
		
		boolean checkMoveDirection(Move move,Field[][] board){
			
			Cell source 		=  move.getFromCell();
			Cell destination 	=  move.getToCell();
			
			if(destination.getCol()+1 == source.getCol()+1 && destination.getRow()+1 != source.getRow()+1 ||
			   destination.getRow()+1 == source.getRow()+1 && destination.getCol()+1 != source.getCol()+1){
				
				return true;
				
			}else{
				return false;
			}
			
		}
		
		//------------------------------------------------------------------
		
		//pruefen ob Spielsteine beim zug den weg versperren.
		
		boolean checkMoveDistance(boolean player,Move move,Field[][] board){
			
			Cell source 		=  move.getFromCell();
			Cell destination 	=  move.getToCell();
			
			//waagerechter Zug
			if((destination.getRow()+1 == source.getRow()+1)){
				
					if(source.getCol()+1 < destination.getCol()+1){
						
						for(int i = source.getCol()+2; i <= destination.getCol()+1;i++){
							//fals ein Stein im weg liegt von links nach rechts
							if(board[destination.getRow()+1][i].getContent() != BoardContent.EMPTY){
								return false;
							}
						}
						return true;
					
					}
					
					else if(source.getCol()+1 > destination.getCol()+1){
					
					for(int i = source.getCol(); i >= destination.getCol()+1;i--){
						//fals ein Stein im weg liegt von rechts nach links
						if(board[destination.getRow()+1][i].getContent() != BoardContent.EMPTY){
							return false;
						}
					}
					return true;
				}
			  }
			
			//senkerechter Zug
			else if((destination.getCol()+1 == source.getCol()+1)){
				
				if(source.getRow()+1 < destination.getRow()+1){
					
					for(int i = source.getRow()+2; i <= destination.getRow()+1;i++){
						//fals ein Stein im weg liegt von oben nach unten
						if(board[i][destination.getCol()+1].getContent() != BoardContent.EMPTY){
							return false;
						}
					}
					return true;
					
				}
				
				else if(source.getRow()+1 > destination.getRow()+1){
					
					for(int i = source.getRow(); i >= destination.getRow()+1;i--){
						//fals ein Stein im weg liegt von unten nach oben
						if(board[i][destination.getCol()+1].getContent() != BoardContent.EMPTY){
							return false;
						}
					}
					return true;
					
				}
			}
			return true;
		}
		
		//------------------------------------------------------------------------
		
		//pruefen ob Spielsteine au�er des Koenigs die Turmfelder betreten wollen.
		boolean checkTowers(boolean player,Move move,Field[][] board){
			
			Cell source 		=  move.getFromCell();
			Cell destination 	=  move.getToCell();
			
			//angreifer will Turmfeld betreten
			if(player == true){
				if(board[source.getRow()+1][source.getCol()+1].getContent() == BoardContent.ATTACKER){
					if((destination.getCol() == 0 && destination.getRow() == 0)||
					   (destination.getCol() == 12 && destination.getRow() == 0)||
					   (destination.getCol() == 0 && destination.getRow() == 12)||
					   (destination.getCol() == 12 && destination.getRow() == 12)||
					   (destination.getCol() == 6 && destination.getRow() == 6)){
							return false;
					}
					else{return true;}
				}	
			}
			//Verteidiger will Turmfeld betreten
			if(player == false){
				if(board[source.getRow()+1][source.getCol()+1].getContent() == BoardContent.DEFENDER){
					if((destination.getCol() == 0 && destination.getRow() == 0)||
					   (destination.getCol() == 12 && destination.getRow() == 0)||
					   (destination.getCol() == 0 && destination.getRow() == 12)||
					   (destination.getCol() == 12 && destination.getRow() == 12)||
					   (destination.getCol() == 6 && destination.getRow() == 6)){
							return false;
					}
					else{return true;}
				}
				if(board[source.getRow()+1][source.getCol()+1].getContent() == BoardContent.KING){
					if((destination.getCol() == 0 && destination.getRow() == 0)||
					   (destination.getCol() == 12 && destination.getRow() == 0)||
					   (destination.getCol() == 0 && destination.getRow() == 12)||
					   (destination.getCol() == 12 && destination.getRow() == 12)){
								return true;
							}
				}
			}
			return true;
		}
		
		//-------------------------------------------------------------------------
		
		ArrayList<Move> getAttackerMoves(Field[][] board){
			
			ArrayList<Field> stones = new ArrayList<Field>();
			ArrayList<Move> moves = new ArrayList<Move>();
			
			for(int i = 1; i <= 13; i++){
				for(int j = 1; j <= 13; j++){
					if(board[i][j].getContent() == BoardContent.ATTACKER){
						stones.add(board[i][j]);
					}
				}
			}
			for(int i = 0; i <= stones.size()-1; i++){
				for(int j = 0; j <= 12; j++){
					//schaut ob mit dem mommentanen Stein zuege nach
					//Osten oder Westen moeglich sind,
					//falls Ja, werden diese in einer Arraylist gespeichert.
					if(checkMove(true, new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(j,stones.get(i).getRow())), board)){
						moves.add(new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(j,stones.get(i).getRow())));
					}
					//schaut ob mit dem mommentanen Stein zuege nach
					//Norden oder Sueden moeglich sind,
					//falls Ja, werden diese in einer Arraylist gespeichert.
					if(checkMove(true, new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(stones.get(i).getCol(),j)), board)){
						moves.add(new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(stones.get(i).getCol(),j)));
					}
					
				}
			}
			return moves;
		}
		
		
		ArrayList<Move> getDefenderMoves(Field[][] board){
			
			ArrayList<Field> stones = new ArrayList<Field>();
			ArrayList<Move> moves = new ArrayList<Move>();
			
			for(int i = 1; i <= 13; i++){
				for(int j = 1; j <= 13; j++){
					if((board[i][j].getContent() == BoardContent.DEFENDER) ||
					   (board[i][j].getContent() == BoardContent.KING)){
						stones.add(board[i][j]);
					}
				}
			}
			for(int i = 0; i <= stones.size()-1; i++){
				for(int j = 0; j <= 12; j++){
					//schaut ob mit dem mommentanen Stein zuege nach
					//Osten oder Westen moeglich sind,
					//falls Ja, werden diese in einer Arraylist gespeichert.
					if(checkMove(false, new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(j,stones.get(i).getRow())), board)){
						moves.add(new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(j,stones.get(i).getRow())));
					}
					//schaut ob mit dem mommentanen Stein zuege nach
					//Norden oder Sueden moeglich sind,
					//falls Ja, werden diese in einer Arraylist gespeichert.
					if(checkMove(false, new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(stones.get(i).getCol(),j)), board)){
						moves.add(new Zug(new Field(stones.get(i).getCol(),stones.get(i).getRow()), new Field(stones.get(i).getCol(),j)));
					}
					
				}
			}
			return moves;
		}
		

		
	}

	class Zug implements Move{
		
		private Cell source;
		private Cell destination;

		public Zug(Cell source, Cell destination) {
			this.source = source;
			this.destination = destination;
		}

		@Override
		public Cell getFromCell() {
			return source;
		}

		@Override
		public Cell getToCell() {
			return destination;
		}
		
		@Override
		public String toString(){
			return String.format(source+" nach "+destination);
		}

	}
}	





